{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6f5bb572",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "import random\n",
    "import time\n",
    "from cvxopt import spmatrix\n",
    "import heapq\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "130c167c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df=pd.read_csv('E:/推荐系统/数据集/MovieLens/ml-latest/ratings.csv')\n",
    "df_copy1=df.copy()     #正负反馈皆有\n",
    "df_copy2=df.copy()      \n",
    "df_copy2=df_copy1[df_copy1['rating']>2.9]     #只有正反馈"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "04a28db7",
   "metadata": {},
   "outputs": [],
   "source": [
    "df=df_copy2.iloc[:50000].sample(frac=1)[['userId','movieId']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ca1ead78",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>userId</th>\n",
       "      <th>movieId</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>22522</th>\n",
       "      <td>225</td>\n",
       "      <td>4776</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>38108</th>\n",
       "      <td>372</td>\n",
       "      <td>912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>47116</th>\n",
       "      <td>464</td>\n",
       "      <td>2997</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22883</th>\n",
       "      <td>235</td>\n",
       "      <td>784</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>56962</th>\n",
       "      <td>564</td>\n",
       "      <td>151</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>48770</th>\n",
       "      <td>478</td>\n",
       "      <td>3697</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>58786</th>\n",
       "      <td>589</td>\n",
       "      <td>1997</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>45535</th>\n",
       "      <td>449</td>\n",
       "      <td>143245</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36881</th>\n",
       "      <td>357</td>\n",
       "      <td>2795</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29356</th>\n",
       "      <td>277</td>\n",
       "      <td>1406</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>50000 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "       userId  movieId\n",
       "22522     225     4776\n",
       "38108     372      912\n",
       "47116     464     2997\n",
       "22883     235      784\n",
       "56962     564      151\n",
       "...       ...      ...\n",
       "48770     478     3697\n",
       "58786     589     1997\n",
       "45535     449   143245\n",
       "36881     357     2795\n",
       "29356     277     1406\n",
       "\n",
       "[50000 rows x 2 columns]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "00263dce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "数据集中的电影部数：7142\n",
      "数据集中的用户数：597\n"
     ]
    }
   ],
   "source": [
    "print(\"数据集中的电影部数：%d\"%len(df['movieId'].unique()))\n",
    "print(\"数据集中的用户数：%d\"%len(df['userId'].unique()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6c055a8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#按比例划分训练集和测试集\n",
    "proportion=0.8\n",
    "train=df.iloc[0:int(proportion*df.shape[0])]\n",
    "test=df.iloc[int(proportion*df.shape[0]):]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "af2c7b04",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\dell\\AppData\\Local\\Temp/ipykernel_19048/3039420440.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  train['popularity']=1\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>movieId</th>\n",
       "      <th>popularity</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>102</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>29</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6527</th>\n",
       "      <td>189333</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6528</th>\n",
       "      <td>189363</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6529</th>\n",
       "      <td>190017</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6530</th>\n",
       "      <td>192081</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6531</th>\n",
       "      <td>192225</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>6532 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      movieId  popularity\n",
       "0           1         102\n",
       "1           2          29\n",
       "2           3          19\n",
       "3           4           1\n",
       "4           5          16\n",
       "...       ...         ...\n",
       "6527   189333           1\n",
       "6528   189363           2\n",
       "6529   190017           1\n",
       "6530   192081           1\n",
       "6531   192225           1\n",
       "\n",
       "[6532 rows x 2 columns]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#物品流行度计算\n",
    "train['popularity']=1\n",
    "df_movie_popularity=train.groupby('movieId').agg('sum').reset_index()\n",
    "df_movie_popularity=df_movie_popularity[['movieId','popularity']]\n",
    "df_movie_popularity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b6a48343",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "程序用时：1130.300136秒\n"
     ]
    }
   ],
   "source": [
    "#计算用户兴趣相似度矩阵W\n",
    "start=time.time()\n",
    "\n",
    "C={}\n",
    "N={}\n",
    "for name, result in train.groupby('movieId'):\n",
    "    reslt=pd.DataFrame(result)\n",
    "    for j in range(result.shape[0]):\n",
    "        if result.iloc[j]['userId'] not in N:\n",
    "            N[result.iloc[j]['userId']]=0\n",
    "        N[result.iloc[j]['userId']]+=1             #N(u),用户u的活跃度\n",
    "        for k in range(j+1,result.shape[0]):\n",
    "          \n",
    "            if result.iloc[k]['userId']==result.iloc[j]['userId']:\n",
    "                continue\n",
    "            else:\n",
    "                if (result.iloc[j]['userId'],result.iloc[k]['userId']) not in C:\n",
    "                    C[result.iloc[j]['userId'],result.iloc[k]['userId']]=0\n",
    "                #改动\n",
    "                if (result.iloc[k]['userId'],result.iloc[j]['userId']) not in C:\n",
    "                    C[result.iloc[k]['userId'],result.iloc[j]['userId']]=0\n",
    "                    \n",
    "                C[result.iloc[j]['userId'],result.iloc[k]['userId']]+=1/math.log(1+result.shape[0])\n",
    "                C[result.iloc[k]['userId'],result.iloc[j]['userId']]+=1/math.log(1+result.shape[0])\n",
    "W={}\n",
    "for key in C:\n",
    "    Nu=N[key[0]]\n",
    "    Nv=N[key[1]]\n",
    "    W[key]=C[key]/(math.sqrt(Nu)*math.sqrt(Nv))\n",
    "            \n",
    "end=time.time()    \n",
    "print(\"程序用时：%f秒\"%(end-start))    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f4d299d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#提取出具有相同兴趣的每一对用户及他们的兴趣相似度\n",
    "user1_lst=[]\n",
    "user2_lst=[]\n",
    "for key in W.keys():\n",
    "    \n",
    "    user1_lst.append(key[0])\n",
    "    user2_lst.append(key[1])\n",
    "\n",
    "df_W=pd.DataFrame({'user1':user1_lst,\n",
    "                   'user2':user2_lst,\n",
    "                   'relevance':list(W.values())})\n",
    "df_W.columns=('user1','user2','relevance')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "bb540357",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>user1</th>\n",
       "      <th>user2</th>\n",
       "      <th>relevance</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>547</td>\n",
       "      <td>313</td>\n",
       "      <td>0.000372</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>313</td>\n",
       "      <td>547</td>\n",
       "      <td>0.000372</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>547</td>\n",
       "      <td>251</td>\n",
       "      <td>0.001534</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>251</td>\n",
       "      <td>547</td>\n",
       "      <td>0.001534</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>547</td>\n",
       "      <td>400</td>\n",
       "      <td>0.000667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>166849</th>\n",
       "      <td>574</td>\n",
       "      <td>422</td>\n",
       "      <td>0.000287</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>166850</th>\n",
       "      <td>339</td>\n",
       "      <td>422</td>\n",
       "      <td>0.000098</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>166851</th>\n",
       "      <td>422</td>\n",
       "      <td>339</td>\n",
       "      <td>0.000098</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>166852</th>\n",
       "      <td>444</td>\n",
       "      <td>422</td>\n",
       "      <td>0.000383</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>166853</th>\n",
       "      <td>422</td>\n",
       "      <td>444</td>\n",
       "      <td>0.000383</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>166854 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "        user1  user2  relevance\n",
       "0         547    313   0.000372\n",
       "1         313    547   0.000372\n",
       "2         547    251   0.001534\n",
       "3         251    547   0.001534\n",
       "4         547    400   0.000667\n",
       "...       ...    ...        ...\n",
       "166849    574    422   0.000287\n",
       "166850    339    422   0.000098\n",
       "166851    422    339   0.000098\n",
       "166852    444    422   0.000383\n",
       "166853    422    444   0.000383\n",
       "\n",
       "[166854 rows x 3 columns]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_W"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6e260a7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_W=pd.read_csv('E:/推荐系统/代码/中间量/User_based-CF_movielens中等数据集（部分）.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "27619c4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#给定一个用户以及和他有相同兴趣的所有用户，找出前K个兴趣相似度最大的用户\n",
    "def findKUser(user2,relevance,K):\n",
    "    user2=np.array(user2)\n",
    "    relevance=np.array(relevance)\n",
    "    index=np.argsort(relevance)[-K:]\n",
    "    return user2[index],relevance[index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "16d81971",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Recall_func(item1,item2):\n",
    "    return len( list(set(item1).intersection(set(item2))) )/len(item2)\n",
    "def Precision_func(item1,item2):\n",
    "    return len( list(set(item1).intersection(set(item2))) )/len(item1)\n",
    "def Coverage_func(item1,item2):\n",
    "    return len(item1)/len(train['movieId'].unique())\n",
    "def Popularity_func(item1,df_movie_popularity):\n",
    "    popularity=0\n",
    "    n=0\n",
    "    for item in item1:\n",
    "        popularity=popularity+df_movie_popularity[df_movie_popularity['movieId']==item]['popularity'].values\n",
    "        n+=1\n",
    "    return popularity/n\n",
    "#给定对一个测试用户的推荐名单和该用户对名单上物品的感兴趣程度，挑选前K个最感兴趣的返回\n",
    "def get_K2_item1(rank,K2):\n",
    "    if len(rank.values())<=K2:\n",
    "        K2_item1=list(rank.keys())\n",
    "        \n",
    "    else:\n",
    "        rank_keys=list(rank.keys())\n",
    "        rank_values=list(rank.values())\n",
    "        index=list(np.argsort(rank_values)[-K2:])\n",
    "        K2_item1=[]\n",
    "        for i in range(len(index)):\n",
    "            K2_item1.append(rank_keys[index[i]])\n",
    "        \n",
    "    return K2_item1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76b27ec5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "bc27ae53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "无法对用户198做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户244做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户264做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户398做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "覆盖率为0.258233\n",
      "召回率为0.270670\n",
      "准确率为0.063556\n",
      "平均流行度为43.509366\n",
      "____________\n",
      "运行时间为43.633481\n"
     ]
    }
   ],
   "source": [
    "start=time.time()\n",
    "\n",
    "Recall=0\n",
    "Precision=0\n",
    "Popularity=0\n",
    "N=1\n",
    "Item1=set()       #最终推荐物品名单\n",
    "Item2=set()       #测试集用户的行为名单\n",
    "K1=20              #K近邻\n",
    "K2=50             #每个用户的推荐数目\n",
    "for user, result in test.groupby('userId'):\n",
    "    '''\n",
    "    对测试集每一个user，先计算出训练集给出的推荐清单item1，再根据user在测试集中的行为得到item2，得到相关指标\n",
    "    '''\n",
    "    \n",
    "    obj_user=user       #目标用户id\n",
    "    rank={}             #用来存储推荐名单的字典\n",
    "    result=pd.DataFrame(result)  #result的movieId列即为item2\n",
    "    item2=result['movieId']        #获取测试集的用户行为\n",
    "    \n",
    "\n",
    "    df_W_obj_user=df_W[df_W['user1']==obj_user]    #获取目标用户与其他用户的兴趣度矩阵部分，即W矩阵的某一行  \n",
    "    if df_W_obj_user.shape[0]==0:  #训练集没有与这个用户存在共同行为的用户\n",
    "        print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中没有与其兴趣相近的用户\")\n",
    "        continue\n",
    "    else:\n",
    "        K_user,K_relevance=findKUser(df_W_obj_user['user2'],df_W_obj_user['relevance'],K1)    #第一个参数是与目标用户具有相关兴趣的所有用户，第二个参数是对应的相关程度\n",
    "    \n",
    "    df_obj_user=train[train['userId']==obj_user]   #目标用户在训练集中的行为\n",
    "    \n",
    "    index=0\n",
    "    for relevant_user in K_user:   #对前K个兴趣度最大的用户，遍历他们的行为，选择没有在目标用户中出现过的\n",
    "        df_relevant_user=train[train['userId']==relevant_user]       #获取这K个近邻用户的训练集数据\n",
    "        \n",
    "        for otherUser_item in df_relevant_user['movieId']:          #获取近邻用户的产生行为的物品\n",
    "            if otherUser_item in set(df_obj_user['movieId']): #如果这个物品出现在了目标用户的训练集中，继续遍历下一个物品\n",
    "                continue\n",
    "            else:             #将该物品加入rank中，更新咪表用户对该商品的兴趣度\n",
    "                if otherUser_item not in rank.keys():\n",
    "                    rank[otherUser_item]=0\n",
    "                rank[otherUser_item]+=K_relevance[index]*1\n",
    "        index+=1\n",
    "        \n",
    "    if len(rank.keys())==0:\n",
    "        print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中与其兴趣相近的用户所作用的物品均被其作用过\")\n",
    "        continue\n",
    "        \n",
    "    #print(rank)  \n",
    "    #rank存储了每一个测试集中的目标用户，训练集对他们做出的推荐名单及他们对物品的兴趣\n",
    "    item2=list(item2)\n",
    "    #item1=list(rank.keys())\n",
    "    item1=get_K2_item1(rank,K2)\n",
    "    Item1=Item1.union(set(item1))\n",
    "    Item2=Item2.union(set(item2))\n",
    "    \n",
    "    popularity=Popularity_func(item1,df_movie_popularity)\n",
    "    recall=Recall_func(item1,item2)\n",
    "    precision=Precision_func(item1,item2)\n",
    "\n",
    "    \n",
    "    Popularity=(N-1)*Popularity/N + popularity/N\n",
    "    Recall=(N-1)*Recall/N + recall/N\n",
    "    Precision=(N-1)*Precision/N + precision/N\n",
    "    N+=1\n",
    "    \n",
    "Coverage=Coverage_func(Item1,Item2)   \n",
    "print(\"覆盖率为%f\"%Coverage)\n",
    "print(\"召回率为%f\"%Recall)  \n",
    "print(\"准确率为%f\"%Precision)\n",
    "print(\"平均流行度为%f\"%Popularity)\n",
    "        \n",
    "    #item1=由训练集给出的user的推荐清单\n",
    "    #根据item1和item2得到相关指标\n",
    "end=time.time()\n",
    "print(\"____________\")\n",
    "print(\"运行时间为%f\"%(end-start))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "da50f87d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=5\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=10\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=20\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=40\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=80\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=160\n",
      "用时：590.826582秒\n"
     ]
    }
   ],
   "source": [
    "start=time.time()\n",
    "K2=100\n",
    "Result_dict={}\n",
    "for K1 in [5,10,20,40,80,160]:\n",
    "    Result_dict[K1]=[]\n",
    "    \n",
    "    Recall=0\n",
    "    Precision=0\n",
    "    Popularity=0\n",
    "    N=1\n",
    "    Item1=set()       #最终推荐物品名单\n",
    "    Item2=set()       #测试集用户的行为名单\n",
    "    for user, result in test.groupby('userId'):\n",
    "        '''\n",
    "        对测试集每一个user，先计算出训练集给出的推荐清单item1，再根据user在测试集中的行为得到item2，得到相关指标\n",
    "        '''\n",
    "\n",
    "        obj_user=user       #目标用户id\n",
    "        rank={}             #用来存储推荐名单的字典\n",
    "        result=pd.DataFrame(result)  #result的movieId列即为item2\n",
    "        item2=result['movieId']        #获取测试集的用户行为\n",
    "\n",
    "\n",
    "        df_W_obj_user=df_W[df_W['user1']==obj_user]    #获取目标用户与其他用户的兴趣度矩阵部分，即W矩阵的某一行  \n",
    "        if df_W_obj_user.shape[0]==0:  #训练集没有与这个用户存在共同行为的用户\n",
    "            print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中没有与其兴趣相近的用户\")\n",
    "            continue\n",
    "        else:\n",
    "            K_user,K_relevance=findKUser(df_W_obj_user['user2'],df_W_obj_user['relevance'],K1)\n",
    "\n",
    "        df_obj_user=train[train['userId']==obj_user]   #目标用户在训练集中的行为\n",
    "\n",
    "        index=0\n",
    "        for relevant_user in K_user:   #对前K个兴趣度最大的用户，遍历他们的行为，选择没有在目标用户中出现过的\n",
    "            df_relevant_user=train[train['userId']==relevant_user]       #获取这K个近邻用户的训练集数据\n",
    "\n",
    "            for otherUser_item in df_relevant_user['movieId']:          #获取近邻用户的产生行为的物品\n",
    "                if otherUser_item in set(df_obj_user['movieId']): #如果这个物品出现在了目标用户的训练集中，继续遍历下一个物品\n",
    "                    continue\n",
    "                else:             #将该物品加入rank中，更新咪表用户对该商品的兴趣度\n",
    "                    if otherUser_item not in rank.keys():\n",
    "                        rank[otherUser_item]=0\n",
    "                    rank[otherUser_item]+=K_relevance[index]*1\n",
    "            index+=1\n",
    "\n",
    "        if len(rank.keys())==0:\n",
    "            print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中与其兴趣相近的用户所作用的物品均被其作用过\")\n",
    "            continue\n",
    "\n",
    "        #print(rank)  \n",
    "        #rank存储了每一个测试集中的目标用户，训练集对他们做出的推荐名单及他们对物品的兴趣\n",
    "        item2=list(item2)\n",
    "        item1=list(rank.keys())\n",
    "        #改动\n",
    "        item1=get_K2_item1(rank,K2)  #在原始item1中，根据目标用户对item的不同感兴趣程度（rank的取值）来挑选前K个最感兴趣的\n",
    "        Item1=Item1.union(set(item1))\n",
    "        Item2=Item2.union(set(item2))\n",
    "\n",
    "        popularity=Popularity_func(item1,df_movie_popularity)    #根据最终的item1计算这个推荐名单的平均流行度\n",
    "        recall=Recall_func(item1,item2)\n",
    "        precision=Precision_func(item1,item2)\n",
    "\n",
    "        Popularity=(N-1)*Popularity/N+popularity/N\n",
    "        Recall=(N-1)*Recall/N+recall/N\n",
    "        Precision=(N-1)*Precision/N+precision/N\n",
    "        N+=1\n",
    "\n",
    "    Coverage=Coverage_func(Item1,Item2)   \n",
    "    \n",
    "    Result_dict[K1].append(Recall)\n",
    "    Result_dict[K1].append(Precision)\n",
    "    Result_dict[K1].append(Coverage)\n",
    "    Result_dict[K1].append(Popularity)\n",
    "    \n",
    "    print(\"K1=%d\"%K1)\n",
    "    \n",
    "end=time.time()\n",
    "print(\"用时：%f秒\"%(-start+end))\n",
    "#     print(\"覆盖率为%f\"%Coverage)\n",
    "#     print(\"召回率为%f\"%Recall)  \n",
    "#     print(\"准确率为%f\"%Precision)\n",
    "#     print(\"平均流行度为%f\"%Popularity)\n",
    "\n",
    "        #item1=由训练集给出的user的推荐清单\n",
    "        #根据item1和item2得到相关指标\n",
    "\n",
    "#     print(\"____________\")\n",
    "#     print(\"运行时间为%f\"%(end-start))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ac31e9a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "K2_100=Result_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "444f5f06",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=5\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=10\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=20\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=40\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=80\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=160\n",
      "用时：568.680901秒\n"
     ]
    }
   ],
   "source": [
    "start=time.time()\n",
    "K2=75\n",
    "Result_dict={}\n",
    "for K1 in [5,10,20,40,80,160]:\n",
    "    Result_dict[K1]=[]\n",
    "    \n",
    "    Recall=0\n",
    "    Precision=0\n",
    "    Popularity=0\n",
    "    N=1\n",
    "    Item1=set()       #最终推荐物品名单\n",
    "    Item2=set()       #测试集用户的行为名单\n",
    "    for user, result in test.groupby('userId'):\n",
    "        '''\n",
    "        对测试集每一个user，先计算出训练集给出的推荐清单item1，再根据user在测试集中的行为得到item2，得到相关指标\n",
    "        '''\n",
    "\n",
    "        obj_user=user       #目标用户id\n",
    "        rank={}             #用来存储推荐名单的字典\n",
    "        result=pd.DataFrame(result)  #result的movieId列即为item2\n",
    "        item2=result['movieId']        #获取测试集的用户行为\n",
    "\n",
    "\n",
    "        df_W_obj_user=df_W[df_W['user1']==obj_user]    #获取目标用户与其他用户的兴趣度矩阵部分，即W矩阵的某一行  \n",
    "        if df_W_obj_user.shape[0]==0:  #训练集没有与这个用户存在共同行为的用户\n",
    "            print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中没有与其兴趣相近的用户\")\n",
    "            continue\n",
    "        else:\n",
    "            K_user,K_relevance=findKUser(df_W_obj_user['user2'],df_W_obj_user['relevance'],K1)\n",
    "\n",
    "        df_obj_user=train[train['userId']==obj_user]   #目标用户在训练集中的行为\n",
    "\n",
    "        index=0\n",
    "        for relevant_user in K_user:   #对前K个兴趣度最大的用户，遍历他们的行为，选择没有在目标用户中出现过的\n",
    "            df_relevant_user=train[train['userId']==relevant_user]       #获取这K个近邻用户的训练集数据\n",
    "\n",
    "            for otherUser_item in df_relevant_user['movieId']:          #获取近邻用户的产生行为的物品\n",
    "                if otherUser_item in set(df_obj_user['movieId']): #如果这个物品出现在了目标用户的训练集中，继续遍历下一个物品\n",
    "                    continue\n",
    "                else:             #将该物品加入rank中，更新咪表用户对该商品的兴趣度\n",
    "                    if otherUser_item not in rank.keys():\n",
    "                        rank[otherUser_item]=0\n",
    "                    rank[otherUser_item]+=K_relevance[index]*1\n",
    "            index+=1\n",
    "\n",
    "        if len(rank.keys())==0:\n",
    "            print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中与其兴趣相近的用户所作用的物品均被其作用过\")\n",
    "            continue\n",
    "\n",
    "        #print(rank)  \n",
    "        #rank存储了每一个测试集中的目标用户，训练集对他们做出的推荐名单及他们对物品的兴趣\n",
    "        item2=list(item2)\n",
    "        item1=list(rank.keys())\n",
    "        #改动\n",
    "        item1=get_K2_item1(rank,K2)  #在原始item1中，根据目标用户对item的不同感兴趣程度（rank的取值）来挑选前K个最感兴趣的\n",
    "        Item1=Item1.union(set(item1))\n",
    "        Item2=Item2.union(set(item2))\n",
    "\n",
    "        popularity=Popularity_func(item1,df_movie_popularity)    #根据最终的item1计算这个推荐名单的平均流行度\n",
    "        recall=Recall_func(item1,item2)\n",
    "        precision=Precision_func(item1,item2)\n",
    "\n",
    "        Popularity=(N-1)*Popularity/N+popularity/N\n",
    "        Recall=(N-1)*Recall/N+recall/N\n",
    "        Precision=(N-1)*Precision/N+precision/N\n",
    "        N+=1\n",
    "\n",
    "    Coverage=Coverage_func(Item1,Item2)   \n",
    "    \n",
    "    Result_dict[K1].append(Recall)\n",
    "    Result_dict[K1].append(Precision)\n",
    "    Result_dict[K1].append(Coverage)\n",
    "    Result_dict[K1].append(Popularity)\n",
    "    \n",
    "    print(\"K1=%d\"%K1)\n",
    "    \n",
    "end=time.time()\n",
    "print(\"用时：%f秒\"%(-start+end))\n",
    "#     print(\"覆盖率为%f\"%Coverage)\n",
    "#     print(\"召回率为%f\"%Recall)  \n",
    "#     print(\"准确率为%f\"%Precision)\n",
    "#     print(\"平均流行度为%f\"%Popularity)\n",
    "\n",
    "        #item1=由训练集给出的user的推荐清单\n",
    "        #根据item1和item2得到相关指标\n",
    "\n",
    "#     print(\"____________\")\n",
    "#     print(\"运行时间为%f\"%(end-start))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "92e5a49b",
   "metadata": {},
   "outputs": [],
   "source": [
    "K2_75=Result_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "25e45c41",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=5\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=10\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=20\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=40\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=80\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=160\n",
      "用时：555.943020秒\n"
     ]
    }
   ],
   "source": [
    "start=time.time()\n",
    "K2=50\n",
    "Result_dict={}\n",
    "for K1 in [5,10,20,40,80,160]:\n",
    "    Result_dict[K1]=[]\n",
    "    \n",
    "    Recall=0\n",
    "    Precision=0\n",
    "    Popularity=0\n",
    "    N=1\n",
    "    Item1=set()       #最终推荐物品名单\n",
    "    Item2=set()       #测试集用户的行为名单\n",
    "    for user, result in test.groupby('userId'):\n",
    "        '''\n",
    "        对测试集每一个user，先计算出训练集给出的推荐清单item1，再根据user在测试集中的行为得到item2，得到相关指标\n",
    "        '''\n",
    "\n",
    "        obj_user=user       #目标用户id\n",
    "        rank={}             #用来存储推荐名单的字典\n",
    "        result=pd.DataFrame(result)  #result的movieId列即为item2\n",
    "        item2=result['movieId']        #获取测试集的用户行为\n",
    "\n",
    "\n",
    "        df_W_obj_user=df_W[df_W['user1']==obj_user]    #获取目标用户与其他用户的兴趣度矩阵部分，即W矩阵的某一行  \n",
    "        if df_W_obj_user.shape[0]==0:  #训练集没有与这个用户存在共同行为的用户\n",
    "            print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中没有与其兴趣相近的用户\")\n",
    "            continue\n",
    "        else:\n",
    "            K_user,K_relevance=findKUser(df_W_obj_user['user2'],df_W_obj_user['relevance'],K1)\n",
    "\n",
    "        df_obj_user=train[train['userId']==obj_user]   #目标用户在训练集中的行为\n",
    "\n",
    "        index=0\n",
    "        for relevant_user in K_user:   #对前K个兴趣度最大的用户，遍历他们的行为，选择没有在目标用户中出现过的\n",
    "            df_relevant_user=train[train['userId']==relevant_user]       #获取这K个近邻用户的训练集数据\n",
    "\n",
    "            for otherUser_item in df_relevant_user['movieId']:          #获取近邻用户的产生行为的物品\n",
    "                if otherUser_item in set(df_obj_user['movieId']): #如果这个物品出现在了目标用户的训练集中，继续遍历下一个物品\n",
    "                    continue\n",
    "                else:             #将该物品加入rank中，更新咪表用户对该商品的兴趣度\n",
    "                    if otherUser_item not in rank.keys():\n",
    "                        rank[otherUser_item]=0\n",
    "                    rank[otherUser_item]+=K_relevance[index]*1\n",
    "            index+=1\n",
    "\n",
    "        if len(rank.keys())==0:\n",
    "            print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中与其兴趣相近的用户所作用的物品均被其作用过\")\n",
    "            continue\n",
    "\n",
    "        #print(rank)  \n",
    "        #rank存储了每一个测试集中的目标用户，训练集对他们做出的推荐名单及他们对物品的兴趣\n",
    "        item2=list(item2)\n",
    "        item1=list(rank.keys())\n",
    "        #改动\n",
    "        item1=get_K2_item1(rank,K2)  #在原始item1中，根据目标用户对item的不同感兴趣程度（rank的取值）来挑选前K个最感兴趣的\n",
    "        Item1=Item1.union(set(item1))\n",
    "        Item2=Item2.union(set(item2))\n",
    "\n",
    "        popularity=Popularity_func(item1,df_movie_popularity)    #根据最终的item1计算这个推荐名单的平均流行度\n",
    "        recall=Recall_func(item1,item2)\n",
    "        precision=Precision_func(item1,item2)\n",
    "\n",
    "        Popularity=(N-1)*Popularity/N+popularity/N\n",
    "        Recall=(N-1)*Recall/N+recall/N\n",
    "        Precision=(N-1)*Precision/N+precision/N\n",
    "        N+=1\n",
    "\n",
    "    Coverage=Coverage_func(Item1,Item2)   \n",
    "    \n",
    "    Result_dict[K1].append(Recall)\n",
    "    Result_dict[K1].append(Precision)\n",
    "    Result_dict[K1].append(Coverage)\n",
    "    Result_dict[K1].append(Popularity)\n",
    "    \n",
    "    print(\"K1=%d\"%K1)\n",
    "    \n",
    "end=time.time()\n",
    "print(\"用时：%f秒\"%(-start+end))\n",
    "#     print(\"覆盖率为%f\"%Coverage)\n",
    "#     print(\"召回率为%f\"%Recall)  \n",
    "#     print(\"准确率为%f\"%Precision)\n",
    "#     print(\"平均流行度为%f\"%Popularity)\n",
    "\n",
    "        #item1=由训练集给出的user的推荐清单\n",
    "        #根据item1和item2得到相关指标\n",
    "\n",
    "#     print(\"____________\")\n",
    "#     print(\"运行时间为%f\"%(end-start))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "57416ab3",
   "metadata": {},
   "outputs": [],
   "source": [
    "K2_50=Result_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "1c7889e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=5\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=10\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=20\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=40\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=80\n",
      "无法对用户230做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "无法对用户352做出推荐，因为训练集中没有与其兴趣相近的用户\n",
      "K1=160\n",
      "用时：545.035526秒\n"
     ]
    }
   ],
   "source": [
    "start=time.time()\n",
    "K2=25\n",
    "Result_dict={}\n",
    "for K1 in [5,10,20,40,80,160]:\n",
    "    Result_dict[K1]=[]\n",
    "    \n",
    "    Recall=0\n",
    "    Precision=0\n",
    "    Popularity=0\n",
    "    N=1\n",
    "    Item1=set()       #最终推荐物品名单\n",
    "    Item2=set()       #测试集用户的行为名单\n",
    "    for user, result in test.groupby('userId'):\n",
    "        '''\n",
    "        对测试集每一个user，先计算出训练集给出的推荐清单item1，再根据user在测试集中的行为得到item2，得到相关指标\n",
    "        '''\n",
    "\n",
    "        obj_user=user       #目标用户id\n",
    "        rank={}             #用来存储推荐名单的字典\n",
    "        result=pd.DataFrame(result)  #result的movieId列即为item2\n",
    "        item2=result['movieId']        #获取测试集的用户行为\n",
    "\n",
    "\n",
    "        df_W_obj_user=df_W[df_W['user1']==obj_user]    #获取目标用户与其他用户的兴趣度矩阵部分，即W矩阵的某一行  \n",
    "        if df_W_obj_user.shape[0]==0:  #训练集没有与这个用户存在共同行为的用户\n",
    "            print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中没有与其兴趣相近的用户\")\n",
    "            continue\n",
    "        else:\n",
    "            K_user,K_relevance=findKUser(df_W_obj_user['user2'],df_W_obj_user['relevance'],K1)\n",
    "\n",
    "        df_obj_user=train[train['userId']==obj_user]   #目标用户在训练集中的行为\n",
    "\n",
    "        index=0\n",
    "        for relevant_user in K_user:   #对前K个兴趣度最大的用户，遍历他们的行为，选择没有在目标用户中出现过的\n",
    "            df_relevant_user=train[train['userId']==relevant_user]       #获取这K个近邻用户的训练集数据\n",
    "\n",
    "            for otherUser_item in df_relevant_user['movieId']:          #获取近邻用户的产生行为的物品\n",
    "                if otherUser_item in set(df_obj_user['movieId']): #如果这个物品出现在了目标用户的训练集中，继续遍历下一个物品\n",
    "                    continue\n",
    "                else:             #将该物品加入rank中，更新咪表用户对该商品的兴趣度\n",
    "                    if otherUser_item not in rank.keys():\n",
    "                        rank[otherUser_item]=0\n",
    "                    rank[otherUser_item]+=K_relevance[index]*1\n",
    "            index+=1\n",
    "\n",
    "        if len(rank.keys())==0:\n",
    "            print(\"无法对用户\"+str(obj_user)+\"做出推荐，因为训练集中与其兴趣相近的用户所作用的物品均被其作用过\")\n",
    "            continue\n",
    "\n",
    "        #print(rank)  \n",
    "        #rank存储了每一个测试集中的目标用户，训练集对他们做出的推荐名单及他们对物品的兴趣\n",
    "        item2=list(item2)\n",
    "        item1=list(rank.keys())\n",
    "        #改动\n",
    "        item1=get_K2_item1(rank,K2)  #在原始item1中，根据目标用户对item的不同感兴趣程度（rank的取值）来挑选前K个最感兴趣的\n",
    "        Item1=Item1.union(set(item1))\n",
    "        Item2=Item2.union(set(item2))\n",
    "\n",
    "        popularity=Popularity_func(item1,df_movie_popularity)    #根据最终的item1计算这个推荐名单的平均流行度\n",
    "        recall=Recall_func(item1,item2)\n",
    "        precision=Precision_func(item1,item2)\n",
    "\n",
    "        Popularity=(N-1)*Popularity/N+popularity/N\n",
    "        Recall=(N-1)*Recall/N+recall/N\n",
    "        Precision=(N-1)*Precision/N+precision/N\n",
    "        N+=1\n",
    "\n",
    "    Coverage=Coverage_func(Item1,Item2)   \n",
    "    \n",
    "    Result_dict[K1].append(Recall)\n",
    "    Result_dict[K1].append(Precision)\n",
    "    Result_dict[K1].append(Coverage)\n",
    "    Result_dict[K1].append(Popularity)\n",
    "    \n",
    "    print(\"K1=%d\"%K1)\n",
    "    \n",
    "end=time.time()\n",
    "print(\"用时：%f秒\"%(-start+end))\n",
    "#     print(\"覆盖率为%f\"%Coverage)\n",
    "#     print(\"召回率为%f\"%Recall)  \n",
    "#     print(\"准确率为%f\"%Precision)\n",
    "#     print(\"平均流行度为%f\"%Popularity)\n",
    "\n",
    "        #item1=由训练集给出的user的推荐清单\n",
    "        #根据item1和item2得到相关指标\n",
    "\n",
    "#     print(\"____________\")\n",
    "#     print(\"运行时间为%f\"%(end-start))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "31298b07",
   "metadata": {},
   "outputs": [],
   "source": [
    "K2_25=Result_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "ce22cbcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "Result_sum={}\n",
    "for K2 in [25,50,75,100]:\n",
    "    for loc,index in enumerate(['Recall','Precision','Coverage','Popularity']):\n",
    "        if (K2,index) not in Result_sum:\n",
    "            Result_sum[(K2,index)]=[]\n",
    "        if K2==25:\n",
    "            for j in range(6):\n",
    "                Result_sum[(K2,index)].append(list(K2_25.values())[j][loc])\n",
    "        if K2==50:\n",
    "            for j in range(6):\n",
    "                Result_sum[(K2,index)].append(list(K2_50.values())[j][loc])\n",
    "        if K2==75:\n",
    "            for j in range(6):\n",
    "                Result_sum[(K2,index)].append(list(K2_75.values())[j][loc])\n",
    "        if K2==100:\n",
    "            for j in range(6):\n",
    "                Result_sum[(K2,index)].append(list(K2_100.values())[j][loc])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "309d4d0b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(25, 'Recall'): [0.3187048171639787,\n",
       "  0.3533015249708895,\n",
       "  0.37115558884232497,\n",
       "  0.34436858652568697,\n",
       "  0.30935572589421917,\n",
       "  0.28031465739998684],\n",
       " (25, 'Precision'): [0.12213625301801113,\n",
       "  0.1316270566727605,\n",
       "  0.13945155393053008,\n",
       "  0.13784277879341852,\n",
       "  0.12994515539305307,\n",
       "  0.11941499085923232],\n",
       " (25, 'Coverage'): [0.2400489895897122,\n",
       "  0.18233312921004285,\n",
       "  0.11956521739130435,\n",
       "  0.072106552357624,\n",
       "  0.046846295162278014,\n",
       "  0.037966932026944275],\n",
       " (25, 'Popularity'): [array([50.31350109]),\n",
       "  array([58.94223035]),\n",
       "  array([70.04680073]),\n",
       "  array([80.05630713]),\n",
       "  array([87.63912249]),\n",
       "  array([92.71488117])],\n",
       " (50, 'Recall'): [0.4003366180707254,\n",
       "  0.4463380060505899,\n",
       "  0.4650727538037398,\n",
       "  0.44203327595304115,\n",
       "  0.39942666407611577,\n",
       "  0.36136329770451225],\n",
       " (50, 'Precision'): [0.0922103491114065,\n",
       "  0.09584769488844876,\n",
       "  0.09996343692870205,\n",
       "  0.09806215722120652,\n",
       "  0.09221206581352837,\n",
       "  0.08628884826325418],\n",
       " (50, 'Coverage'): [0.3320575627679118,\n",
       "  0.2735762400489896,\n",
       "  0.18585425597060626,\n",
       "  0.11053276178812002,\n",
       "  0.07501530924678505,\n",
       "  0.06261481935088793],\n",
       " (50, 'Popularity'): [array([45.25800029]),\n",
       "  array([50.26491774]),\n",
       "  array([59.21104205]),\n",
       "  array([68.18438757]),\n",
       "  array([74.12062157]),\n",
       "  array([78.35630713])],\n",
       " (75, 'Recall'): [0.44034454699789194,\n",
       "  0.4998586920081715,\n",
       "  0.5225219729156079,\n",
       "  0.5027793346300371,\n",
       "  0.46141604838085626,\n",
       "  0.4176078303053006],\n",
       " (75, 'Precision'): [0.0807635462006567,\n",
       "  0.07801711474327046,\n",
       "  0.08041539711557985,\n",
       "  0.0788543570993296,\n",
       "  0.07502742230347344,\n",
       "  0.06961608775137099],\n",
       " (75, 'Coverage'): [0.3952847519902021,\n",
       "  0.34109001837109615,\n",
       "  0.2424984690753215,\n",
       "  0.14620330679730556,\n",
       "  0.09675443968156766,\n",
       "  0.08358848744641764],\n",
       " (75, 'Popularity'): [array([42.42758024]),\n",
       "  array([45.19720097]),\n",
       "  array([52.39587751]),\n",
       "  array([60.584156]),\n",
       "  array([65.87709933]),\n",
       "  array([69.90096283])],\n",
       " (100, 'Recall'): [0.46485636300599675,\n",
       "  0.5356820574295386,\n",
       "  0.5585662049327332,\n",
       "  0.5464197319187786,\n",
       "  0.5060909769221313,\n",
       "  0.46864643971931214],\n",
       " (100, 'Precision'): [0.0735529279105416,\n",
       "  0.0681388076273865,\n",
       "  0.0680391022189548,\n",
       "  0.06731261425959782,\n",
       "  0.06411334552102374,\n",
       "  0.0602010968921389],\n",
       " (100, 'Coverage'): [0.4422841396203307,\n",
       "  0.40293937538273117,\n",
       "  0.29393753827311697,\n",
       "  0.17911818738518065,\n",
       "  0.1191059399877526,\n",
       "  0.10088793631353338],\n",
       " (100, 'Popularity'): [array([40.72717194]),\n",
       "  array([41.95174308]),\n",
       "  array([47.81190727]),\n",
       "  array([55.09409506]),\n",
       "  array([60.37382084]),\n",
       "  array([63.98921389])]}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Result_sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "351906fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x27fb6241b20>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['font.sans-serif']=['SimHei']\n",
    "plt.rcParams['axes.unicode_minus'] = False\n",
    "for K2 in [25,50,75,100]:\n",
    "    y=Result_sum[(K2,'Recall')]\n",
    "    x=[5,10,20,40,80,160]\n",
    "    plt.plot(x,y,label='K2='+str(K2))\n",
    "    plt.xlabel(\"K近邻个数\")\n",
    "    plt.ylabel(\"Recall\")\n",
    "    plt.title(\"Recall\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "3ba48404",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x27fb82250a0>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for K2 in [25,50,75,100]:\n",
    "    y=Result_sum[(K2,'Precision')]\n",
    "    x=[5,10,20,40,80,160]\n",
    "    plt.plot(x,y,label='K2='+str(K2))\n",
    "    plt.xlabel(\"K近邻个数\")\n",
    "    plt.ylabel(\"Precision\")\n",
    "    plt.title(\"Precision\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "cb68d287",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x27fb82ab040>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for K2 in [25,50,75,100]:\n",
    "    y=Result_sum[(K2,'Coverage')]\n",
    "    x=[5,10,20,40,80,160]\n",
    "    plt.plot(x,y,label='K2='+str(K2))\n",
    "    plt.xlabel(\"K近邻个数\")\n",
    "    plt.ylabel(\"Coverage\")\n",
    "    plt.title(\"Coverage\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a3d8c3d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x27fb8325610>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for K2 in [25,50,75,100]:\n",
    "    y=Result_sum[(K2,'Popularity')]\n",
    "    x=[5,10,20,40,80,160]\n",
    "    plt.plot(x,y,label='K2='+str(K2))\n",
    "    plt.xlabel(\"K近邻个数\")\n",
    "    plt.ylabel(\"Popularity\")\n",
    "    plt.title(\"Popularity\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84e10b47",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94cfc73a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
